البرمجة الكائنية التوجه (OOP) هي أسلوب برمجي يعتمد على الكائنات والفئات لتنظيم الكود وتسهيل إعادة استخدامه. في هذه الدورة، سنغطي كل المفاهيم الأساسية والمتقدمة لـ OOP مع أمثلة عملية لفهم كيفية تطبيقها في تصميم البرمجيات.
البرمجة الكائنية (OOP) هي نمط برمجي يعتمد على الكائنات التي تجمع البيانات والسلوكيات معًا.
                            class Car:
                                def __init__(self, brand):
                                    self.brand = brand
                                def drive(self):
                                    print(f"{self.brand} is driving")
                            my_car = Car("Toyota")
                            my_car.drive()  # Toyota is driving
                        
                    التغليف يحمي البيانات داخل الكائن ويحد من الوصول المباشر إليها.
__ لجعلها غير قابلة للوصول مباشرة.
                            class Car:
                                def __init__(self, brand):
                                    self.__brand = brand
                                def get_brand(self):
                                    return self.__brand
                                def set_brand(self, brand):
                                    self.__brand = brand
                            my_car = Car("BMW")
                            print(my_car.get_brand())  # BMW
                            my_car.set_brand("Audi")
                            print(my_car.get_brand())  # Audi
                        
                    الوراثة تتيح لفئة جديدة أن ترث خصائص ووظائف فئة أخرى.
                            class Vehicle:
                                def __init__(self, brand):
                                    self.brand = brand
                                def move(self):
                                    print(f"{self.brand} moves")
                            class Car(Vehicle):
                                def honk(self):
                                    print("Beep!")
                            my_car = Car("Toyota")
                            my_car.move()  # Toyota moves
                            my_car.honk()  # Beep!
                        
                    تعدد الأشكال يسمح للكائنات المختلفة بالاستجابة لنفس الوظيفة بطرق مختلفة.
                            class Animal:
                                def sound(self):
                                    print("Some sound")
                            class Dog(Animal):
                                def sound(self):
                                    print("Woof!")
                            class Cat(Animal):
                                def sound(self):
                                    print("Meow!")
                            animals = [Dog(), Cat()]
                            for a in animals:
                                a.sound()  # Woof! Meow!
                        
                    التجريد يُركز على إخفاء التفاصيل الداخلية وإظهار الوظائف الأساسية فقط.
                            from abc import ABC, abstractmethod
                            class Shape(ABC):
                                @abstractmethod
                                def area(self):
                                    pass
                            class Circle(Shape):
                                def __init__(self, radius):
                                    self.radius = radius
                                def area(self):
                                    return 3.14 * self.radius ** 2
                            c = Circle(5)
                            print(c.area())  # 78.5
                        
                    الواجهات تحدد مجموعة من الوظائف التي يجب تطبيقها.
                            from abc import ABC, abstractmethod
                            class Flyable(ABC):
                                @abstractmethod
                                def fly(self):
                                    pass
                            class Bird(Flyable):
                                def fly(self):
                                    print("Flying!")
                            b = Bird()
                            b.fly()  # Flying!
                        
                    حلول معيارية لمشاكل شائعة في تصميم البرمجيات.
                            class Singleton:
                                _instance = None
                                def __new__(cls):
                                    if cls._instance is None:
                                        cls._instance = super().__new__(cls)
                                    return cls._instance
                            s1 = Singleton()
                            s2 = Singleton()
                            print(s1 is s2)  # True
                        
                    الوراثة من أكثر من فئة أم.
                            class Engine:
                                def start(self):
                                    print("Engine started")
                            class Wheels:
                                def roll(self):
                                    print("Wheels rolling")
                            class Car(Engine, Wheels):
                                pass
                            my_car = Car()
                            my_car.start()  # Engine started
                            my_car.roll()   # Wheels rolling
                        
                    كيفية تخصيص وتحرير الذاكرة للكائنات.
                            class MyClass:
                                def __init__(self, value):
                                    self.value = value
                            obj1 = MyClass(10)
                            obj2 = obj1
                            print(obj1.value)  # 10
                            del obj1  # لا يزال obj2 يشير إلى الكائن
                            print(obj2.value)  # 10
                        
                    إدارة الأخطاء في سياق OOP.
                            class BankAccount:
                                def __init__(self, balance):
                                    self.balance = balance
                                def withdraw(self, amount):
                                    if amount > self.balance:
                                        raise ValueError("Insufficient funds")
                                    self.balance -= amount
                            account = BankAccount(100)
                            try:
                                account.withdraw(150)
                            except ValueError as e:
                                print(e)  # Insufficient funds
                        
                    الخصائص والوظائف التي تنتمي للفئة وليس للكائنات.
@staticmethod.@classmethod.
                            class MathUtils:
                                @staticmethod
                                def add(a, b):
                                    return a + b
                                @classmethod
                                def class_name(cls):
                                    return cls.__name__
                            print(MathUtils.add(3, 4))  # 7
                            print(MathUtils.class_name())  # MathUtils
                        
                    تعريف وظائف متعددة بنفس الاسم ولكن بمعاملات مختلفة.
                            class Calculator:
                                def add(self, a, b=0, c=0):
                                    return a + b + c
                            calc = Calculator()
                            print(calc.add(5))      # 5
                            print(calc.add(5, 3))   # 8
                            print(calc.add(5, 3, 2))  # 10
                        
                    كيفية ارتباط الكائنات ببعضها (تجميع، تركيب، ارتباط).
                            class Engine:
                                def start(self):
                                    print("Engine started")
                            class Car:
                                def __init__(self):
                                    self.engine = Engine()
                                def drive(self):
                                    self.engine.start()
                                    print("Car is driving")
                            my_car = Car()
                            my_car.drive()
                        
                    تطبيق شامل يجمع المفاهيم السابقة.
                            class Book:
                                def __init__(self, title, author):
                                    self.title = title
                                    self.author = author
                                def info(self):
                                    return f"{self.title} by {self.author}"
                            class Library:
                                def __init__(self):
                                    self.books = []
                                def add_book(self, book):
                                    self.books.append(book)
                                def list_books(self):
                                    for book in self.books:
                                        print(book.info())
                            lib = Library()
                            lib.add_book(Book("Python 101", "Ali"))
                            lib.add_book(Book("OOP Basics", "Ahmed"))
                            lib.list_books()